package org.tbwork.utility.toolbox;

import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Timestamp;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class tbString {

	 /**  根据字符串找到第一个符合正则式的字符。
	 * @param expression 正则表达式
	 * @param orgStr  待匹配字符串
	 * @return 第一个符合正则式的字符
	 */
	public static String jRegex(String expression, String orgStr){
		 Pattern pattern = Pattern.compile(expression);
		 Matcher matcher = pattern.matcher(orgStr);
		 if(matcher.find()){
		   return matcher.group();
		 }
		 else 
		   return "";
	 }
	
	/** 输入流 转 字符串，方法1
	 * @param in 输入流
	 * @param encoding  编码
	 * @return 文本
	 * @throws Exception
	 */
	public static String InputStreamTOString(InputStream in,String encoding) throws Exception{  
        
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();  
        byte[] data = new byte[4096];  
        int count = -1;  
        while((count = in.read(data,0,4096)) != -1)  
            outStream.write(data, 0, count);  
          
        data = null;  
        return new String(outStream.toByteArray(),encoding);  //"ISO-8859-1"
    }  
   
	/** 输入流 转 字符串，方法2
	 * @param is 输入流
	 * @return 输入流 转 字符串，方法2
	 */
	public static String convertStreamToString(InputStream is) {      
        StringBuilder sb1 = new StringBuilder();      
        byte[] bytes = new byte[4096];    
        int size = 0;    
        try {      
            while ((size = is.read(bytes)) > 0) {    
                String str = new String(bytes, 0, size, "UTF-8");    
                sb1.append(str);    
            }    
        } catch (IOException e) {      
            e.printStackTrace();      
        } finally {      
            try {      
                is.close();      
            } catch (IOException e) {      
               e.printStackTrace();      
            }      
        }      
        return sb1.toString();      
    }  
 
	/** 输入流 转 字符串，方法3
	 * @param inStream 输入流
	 * @return
	 * @throws IOException
	 */
	private static final byte[] input2byte(InputStream inStream)  
            throws IOException {  
        ByteArrayOutputStream swapStream = new ByteArrayOutputStream();  
        byte[] buff = new byte[4096];  
        int rc = 0;  
        while ((rc = inStream.read(buff, 0, 4096)) > 0) {  
            swapStream.write(buff, 0, rc);  
        }  
        byte[] in2b = swapStream.toByteArray();  
        return in2b;  
    }

	/**
	 * @param src 源字符串
	 * @param len 字节长度
	 * @return 获取指定字节长度的字符串,如果最后一个字是多字节字符，那么自动删除，
	 */
	public static String getSpecifiedByteLengthString(String src, int len)
	{
		String result ="";
		if(src==null)
			return "";
		int curlen=0;
	    for (int i=0; i<src.length();i++)
		{
	    	int templen = src.substring(i,i+1).getBytes().length;
			if(curlen+templen<len)
			{
				result =result+src.substring(i,i+1);
				curlen =curlen+templen;
			}
			else
			{
				break;
			}
		}
	    return result;
	}
	
	/**
	 * @param src 源字符串
	 * @return 获取指定字符串的字节长度，
	 */
	public static int getByteLengthOfStr(String src)
	{
		if(src==null)
			return 0;
		int curlen=0;
	    for (int i=0; i<src.length();i++)
		{
	    	int templen = src.substring(i,i+1).getBytes().length;
			curlen += templen;
		}
	    return curlen;
	}
	
	
	/**  从某个字符串中匹配出第一个子串
	 * @param src  源字符串
	 * @param regex 正则表达式
	 * @return 返回匹配出第一个子串
	 */
	public static String getRegexString(String src,String regex)
	{
	
		Pattern pat = Pattern.compile(regex);  
		Matcher mat = pat.matcher(src);  
		boolean rs = mat.find();   
		if(rs)
			return mat.group(0);
		else
			return "";
	}
	

	
	/** 判断某个字符是否是 数字或者字母
	 * @param a 目标字符
	 * @return 是数字或者字母就返回true ，否则返回false
	 */
	public  static boolean isNumberOrLetter(char a)
	{
		return   ( a>='0' && a<='9' ) || (a>='a' &&a<='z')  || (a>='A' &&a<='Z');
	}
	
	
	/**
	 * @param str
	 * @return 该函数 合并所有中文之间的空格，对于英文和数字之间的空格则不合并
	 */
	public static String mergeSpace(String str)
	{
	   str = str.replace("　", " ");//假空格 换成真空格	
	   String result ="";
       for(int i=0;i<str.length();i++)
       {
    	   if(str.charAt(i)==' ')
    	   {
    		   int fore = i>0? i-1:0;
    		   int next = i<str.length()-1? i+1:str.length()-1;
    		   if(   isNumberOrLetter(str.charAt(fore))  ||  isNumberOrLetter(str.charAt(next))          )
    		   {
    			   result =result +" ";
    		   }
    	   }
    	   else
    	   {
    		   result = result +str.charAt(i);
    	   }
       }
       //合并连续的双空格
       result = result.replace("  ", " ");
       return result;
	}
	
	/** 
	 * @param str 源字符串
	 * @return  从这个字符串中取出 日期字符串，如 2011-09-09，如果没有，则返回 ""
	 */
	public static String getDateStr(String str)
	{
		Timestamp ts = new Timestamp(System.currentTimeMillis());  
		String result= "";
		Pattern pattern = Pattern.compile("\\d{4,4}-\\d{2,2}-\\d{2,2}");
		Matcher matcher = pattern.matcher(str);
		if(matcher.find()){
			result = matcher.group(0);
		}
		
		return result.substring(0,10);
	}
	
}
